Analüüsi eesmärk on:

* pideva muutuja averageGrade ennustamine.
* andmestiku struktuuri kirjeldamine (dimensionaalsuse vähendamine, klasterdamine).

Algandmed on hoiustatud json failis, mille loen mällu ja kirjutan kolme erinevasse .csv faili, kus igaühes neist on esitatud kõik andmestiku omadused aga veidi erineval kujul, et seda hiljem lihtsam kasutada oleks.

In [1748]:
import json
import csv


def convert_dict_to_csv(dict):
    csv_file = "students"

    csv_columns = ['id', 'uniid', 'lastTested', 'totalCommits', 'totalTestsRan', 'totalTestsPassed',
                   'totalDiagnosticErrors', 'differentSlugs', 'differentCourses', 'commitsStyleOK', 'averageGrade',
                   'medianGrade']  # Last one is the one being predicted

    csv_columns_percent = ['totalDiagnosticErrors_per_totalCommits', 'totalTestsPassed_per_totalTestsRan',
                           'commitsStyleOK_per_totalCommits', ]

    to_drop = ['id', 'uniid', 'lastTested', 'medianGrade']
    to_drop_extra_only = ['totalCommits', 'totalTestsRan', 'differentCourses', 'totalTestsPassed',
                          'totalDiagnosticErrors', 'commitsStyleOK']

    try:

        for i in range(3):
            with open(csv_file + ("_extra.csv" if i == 1 else ".csv" if not i else "_extra_only.csv"), 'w') as csvfile:
                if i == 1:
                    csv_columns = csv_columns_percent + csv_columns

                if i == 2:
                    csv_columns = [x for x in csv_columns if x not in to_drop_extra_only]

                csv_columns = [x for x in csv_columns if x not in to_drop]

                writer = csv.DictWriter(csvfile, delimiter=',', lineterminator='\n', fieldnames=csv_columns)

                csvfile.write(
                    f"{len(dict)},{len(csv_columns) - 1}\n")  # -1 because the last field is the one being predicted
                writer.writeheader()

                for data in reversed(dict):
                    if not i:
                        for drop in to_drop:
                            del data[drop]

                    if i:
                        for extra in csv_columns_percent:
                            left, right = extra.split("_per_")

                            if not data[right]:
                                data[extra] = 0
                            else:
                                data[extra] = data[left] / data[right]

                        if i == 2:
                            for drop in to_drop_extra_only:
                                del data[drop]

                    writer.writerow(data)
    except IOError:
        print("I/O error")



with open('example.json') as f:
    dict_data = json.load(f)
convert_dict_to_csv(dict_data)

student.csv description:

Author: Enrico Vompa Date: 2020.03.20

Data is collected from Arete. (TalTech's automated testing service)

Dataset contains no NULL fields.

Nr of lines: 138 Nr of attributes: 8

Headers:

  • totalCommits (integer) - Total number of commits from the student
  • totalTestsRan (integer) - Total number of tests ran for the student
  • totalTestsPassed (integer) - Total number of tests passed from the tests ran
  • totalDiagnosticErrors (integer) - Total number of diagnostic errors. Diagnostic error = style error in code. Eslint for example.
  • differentSlugs (integer) - Number of different exercises the given student has attempted
  • differentCourses (integer) - Number of different courses the given student has attempted
  • commitsStyleOK (integer) - Number of test jobs ran with no diagnostic errors
  • averageGrade (float) - students' average score

students_extra.csv description:

Author: Enrico Vompa Date: 2020.04.11

Data is collected from Arete. (TalTech's automated testing service)

Dataset contains no NULL fields.

Nr of lines: 138 Nr of attributes: 11

Headers:

  • totalDiagnosticErrors_per_totalCommits (float) - totalDiagnosticErrors divided by totalCommits
  • totalTestsPassed_per_totalTestsRan (float) - totalTestsPassed divided by totalTestsRan
  • commitsStyleOK_per_totalCommits (float) - commitsStyleOK divided by totalCommits
  • totalCommits (integer) - Total number of commits from the student
  • totalTestsRan (integer) - Total number of tests ran for the student
  • totalTestsPassed (integer) - Total number of tests passed from the tests ran
  • totalDiagnosticErrors (integer) - Total number of diagnostic errors. Diagnostic error = style error in code. Eslint for example.
  • differentSlugs (integer) - Number of different exercises the given student has attempted
  • differentCourses (integer) - Number of different courses the given student has attempted
  • commitsStyleOK (integer) - Number of test jobs ran with no diagnostic errors
  • averageGrade (float) - students' average score

students_extra_only.csv description:

Author: Enrico Vompa Date: 2020.04.11

Data is collected from Arete. (TalTech's automated testing service)

Dataset contains no NULL fields.

Nr of lines: 138 Nr of attributes: 5

Headers:

  • totalDiagnosticErrors_per_totalCommits (float) - totalDiagnosticErrors divided by totalCommits
  • totalTestsPassed_per_totalTestsRan (float) - totalTestsPassed divided by totalTestsRan
  • commitsStyleOK_per_totalCommits (float) - commitsStyleOK divided by totalCommits
  • differentSlugs (integer) - Number of different exercises the given student has attempted
  • averageGrade (float) - students' average score
In [1749]:
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
from pandas.plotting import scatter_matrix
from sklearn.cluster import KMeans

def load_dataset(filename):
    with open(filename) as csv_file:
        data_file = csv.reader(csv_file)
        temp = next(data_file)
        n_samples = int(temp[0])
        n_features = int(temp[1])
        temp = next(data_file)
        columns2= [x.strip() for x in temp]
        data = np.empty((n_samples, n_features), dtype=np.int64)
        target = np.empty((n_samples,), dtype=np.int64)

        for i, sample in enumerate(data_file):
            data[i] = np.asarray([int(round(float(x))) for x in sample[:-1]], dtype=np.int64)
            target[i] = np.asarray(int(round(float(sample[-1]) / 10)) * 10, dtype=np.int64)

    return Bunch(data=data, target=target),columns2

def getColumns(filename):
    with open(filename) as f:
        f.readline() # holder for dimensions
        columns = [x.strip() for x in f.readline().split(",")]
        return columns

Alustab andmete lugemisega

In [1750]:
used_columns = getColumns("students.csv")
    
student_df = pd.read_csv("students.csv", 
                      header=2, 
                      names=used_columns)
student_df
Out[1750]:
totalCommits totalTestsRan totalTestsPassed totalDiagnosticErrors differentSlugs differentCourses commitsStyleOK averageGrade
0 110 3071 2377 684 15 1 23 100.000000
1 45 1167 999 532 12 1 9 89.644167
2 165 5050 4445 1486 19 1 59 88.670000
3 393 9636 6812 3615 18 1 90 86.526667
4 29 324 142 288 4 1 3 84.167500
... ... ... ... ... ... ... ... ...
132 6 306 273 64 2 1 2 100.000000
133 10 186 150 109 10 1 5 82.000000
134 3 3 0 2 1 1 1 0.000000
135 10 41 33 1438 2 1 0 40.245000
136 2 66 2 0 1 1 2 6.060000

137 rows × 8 columns

In [1751]:
print("Mean of __")
_ = [print(f"        {x} is: {student_df[x].mean()}") for x in used_columns]
print()

print("Median of __")
_ = [print(f"          {x} is: {student_df[x].median()}") for x in used_columns]
print()

print("Standard deviation of __")
_ = [print(f"                      {x} is: {student_df[x].std()}") for x in used_columns]
Mean of __
        totalCommits is: 128.007299270073
        totalTestsRan is: 3688.204379562044
        totalTestsPassed is: 2776.934306569343
        totalDiagnosticErrors is: 1538.6788321167883
        differentSlugs is: 12.912408759124087
        differentCourses is: 1.0364963503649636
        commitsStyleOK is: 30.021897810218977
        averageGrade is: 80.28005150497724

Median of __
          totalCommits is: 114.0
          totalTestsRan is: 3452.0
          totalTestsPassed is: 2574.0
          totalDiagnosticErrors is: 1173.0
          differentSlugs is: 16.0
          differentCourses is: 1.0
          commitsStyleOK is: 26.0
          averageGrade is: 88.67

Standard deviation of __
                      totalCommits is: 101.1357195547563
                      totalTestsRan is: 3015.727609839023
                      totalTestsPassed is: 2222.3034525821454
                      totalDiagnosticErrors is: 1398.3286606343904
                      differentSlugs is: 6.351788137018564
                      differentCourses is: 0.18820979861687795
                      commitsStyleOK is: 26.573833645282114
                      averageGrade is: 23.1824628371347

Eelnevatest Järeldab, et andmeid on vaja standartiseerida enne nende kasutust.

Histogrammid, et vaadata andmete jaotust

In [1752]:
_ = [student_df.hist(column=x) for x in used_columns] ## Bigger pictures this way

Pairplots, et vaadata andmete jaotust ning uurida, millised kolumni väärtused on omavahel otseselt seotud graafiliselt

In [1753]:
_ = scatter_matrix(student_df, figsize = (25, 25), alpha=0.8)

Sai joonistatud scatter_matix, et proovida leida seoseid testimiselt tulnud andmete ja keskmise hinde vahel. Aga suuri otseseid seoseid ei paista olevat. Selleks tuleks joonistada korrelatsioonimaatriks, et kindel olla.

Korrelatsioonimaatriks, et uurida millised kolumni väärtused on omavahel otseselt seotud

In [1754]:
def histogram_intersection(a, b):
    v = np.minimum(a, b).sum().round(decimals=1)
    return v

student_df.corr(method=histogram_intersection)
Out[1754]:
totalCommits totalTestsRan totalTestsPassed totalDiagnosticErrors differentSlugs differentCourses commitsStyleOK averageGrade
totalCommits 1.0 17531.0 17524.0 17534.0 1769.0 142.0 4113.0 8923.1
totalTestsRan 17531.0 1.0 380440.0 205784.0 1767.0 141.0 4113.0 10818.6
totalTestsPassed 17524.0 380440.0 1.0 199979.0 1764.0 139.0 4110.0 10770.3
totalDiagnosticErrors 17534.0 205784.0 199979.0 1.0 1768.0 141.0 4111.0 10754.4
differentSlugs 1769.0 1767.0 1764.0 1768.0 1.0 142.0 1678.0 1764.0
differentCourses 142.0 141.0 139.0 141.0 142.0 1.0 132.0 139.0
commitsStyleOK 4113.0 4113.0 4110.0 4111.0 1678.0 132.0 1.0 4048.6
averageGrade 8923.1 10818.6 10770.3 10754.4 1764.0 139.0 4048.6 1.0

Siin tunduvad suvalised numbrid olevat, niiet ka see väga palju midagi ei ütle.

Paneb graafikud samasse teljestikku, et vaadata, millised andmed on umbkaudu samas suurusjärgus

In [1755]:
_ = student_df.plot(figsize=(20, 20))

Andmeid on igast suurusjärke, et tuleb standartiseerida kuidagi vastuseid

Joonistab korrelatsiooni koefitsendi maatriksi vahemikus -1 kuni 1, et oleks lihtsamini loetav ning visualiseerib need clustermap'ina ning heatmap'ina

In [1756]:
def draw_coefficient_matrix(student_df):
    X = student_df
    y = student_df.columns
    
    cm = np.corrcoef(X.T)
    sns.set(font_scale=1.5)
    hm = sns.heatmap(cm, cbar=True, annot=True, square=True, fmt='.2f',
                     annot_kws={'size': 6}, yticklabels=X.columns,
                     xticklabels=X.columns, 
                     cmap=sns.diverging_palette(10, 220, sep=80))
    plt.show()

    km = sns.clustermap(cm, cbar=True, annot=True,fmt='.2f',
                        annot_kws={'size': 8}, yticklabels=X.columns,
                        xticklabels=X.columns, 
                        cmap=sns.diverging_palette(10, 220, sep=80))
    plt.show()

draw_coefficient_matrix(student_df)

Eelnevatest andmetest saab järeldata järgmist - Huvitaval kombel pole keskmise hinne otseselt seotud muude kolumni väärtustega. (Koefitsendi väärtused korrelatsioonimaatriksis real averageGrade on alla .4)

Erinevate kursuste arv on vastupidises suhtes erinevate ülesannete arvuga - Mille põhjendus on ilmselt see, et andmeid ei ole piisavalt pika aja peale. Peaks seda faili jooksutama uuesti kunagi tulevikus.

Ootuspäraselt on totalCommits, totalTestsRan ja totalTestsPassed omavahel samasuunalises suhtes.

Panen paar täiendavat fieldi sisse, millest saaks ehk midagi järeldada

In [1757]:
student_df_extra = pd.read_csv("students_extra.csv", 
                      header=2, 
                      names=getColumns("students_extra.csv"))
In [1758]:
draw_coefficient_matrix(student_df_extra)

Ning ootuspäraselt tekkis seos keskmise hinde ning totalTestsPassed_per_totalTestsRan vahel

Aga huvitaval kombel ei ole commitsStyleOK_per_totalCommits ega totalDiagnosticErrors_per_totalCommits vead kuidagi seotud keskmise hindega

In [1759]:
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.cm as cm

def draw_silhouette_plots(X, range_n_clusters = range(2, 10)):

# See kood on võetud suuresti 
# https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_silhouette_analysis.html#sphx-glr-auto-examples-cluster-plot-kmeans-silhouette-analysis-py
    distortions = []
    for n_clusters in range_n_clusters:
        # Create a subplot with 1 row and 2 columns
        fig, (ax1, ax2) = plt.subplots(1, 2)
        fig.set_size_inches(18, 7)

        # The 1st subplot is the silhouette plot
        # The silhouette coefficient can range from -1, 1 but in this example all
        # lie within [-0.1, 1]
        ax1.set_xlim([-0.1, 1])
        # The (n_clusters+1)*10 is for inserting blank space between silhouette
        # plots of individual clusters, to demarcate them clearly.
        ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])

        # Initialize the clusterer with n_clusters value and a random generator
        # seed of 10 for reproducibility.
        clusterer = KMeans(n_clusters=n_clusters, random_state=10)
        cluster_labels = clusterer.fit_predict(X)
        distortions.append(clusterer.inertia_)
        
        # The silhouette_score gives the average value for all the samples.
        # This gives a perspective into the density and separation of the formed
        # clusters
        silhouette_avg = silhouette_score(X, cluster_labels)
        print("For n_clusters =", n_clusters,
              "The average silhouette_score is :", silhouette_avg)

        # Compute the silhouette scores for each sample
        sample_silhouette_values = silhouette_samples(X, cluster_labels)

        y_lower = 10
        for i in range(n_clusters):
            # Aggregate the silhouette scores for samples belonging to
            # cluster i, and sort them
            ith_cluster_silhouette_values = \
                sample_silhouette_values[cluster_labels == i]

            ith_cluster_silhouette_values.sort()

            size_cluster_i = ith_cluster_silhouette_values.shape[0]
            y_upper = y_lower + size_cluster_i

            color = cm.nipy_spectral(float(i) / n_clusters)
            ax1.fill_betweenx(np.arange(y_lower, y_upper),
                              0, ith_cluster_silhouette_values,
                              facecolor=color, edgecolor=color, alpha=0.7)

            # Label the silhouette plots with their cluster numbers at the middle
            ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))

            # Compute the new y_lower for next plot
            y_lower = y_upper + 10  # 10 for the 0 samples

        ax1.set_title("The silhouette plot for the various clusters.")
        ax1.set_xlabel("The silhouette coefficient values")
        ax1.set_ylabel("Cluster label")

        # The vertical line for average silhouette score of all the values
        ax1.axvline(x=silhouette_avg, color="red", linestyle="--")

        ax1.set_yticks([])  # Clear the yaxis labels / ticks
        ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])

        # 2nd Plot showing the actual clusters formed
        colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
        ax2.scatter(X[:, 0], X[:, 1], marker='.', s=30, lw=0, alpha=0.7,
                    c=colors, edgecolor='k')

        # Labeling the clusters
        centers = clusterer.cluster_centers_
        # Draw white circles at cluster centers
        ax2.scatter(centers[:, 0], centers[:, 1], marker='o',
                    c="white", alpha=1, s=200, edgecolor='k')

        for i, c in enumerate(centers):
            ax2.scatter(c[0], c[1], marker='$%d$' % i, alpha=1,
                        s=50, edgecolor='k')

        ax2.set_title("The visualization of the clustered data.")
        ax2.set_xlabel("Feature space for the 1st feature")
        ax2.set_ylabel("Feature space for the 2nd feature")

        plt.suptitle(("Silhouette analysis for KMeans clustering on sample data "
                      "with n_clusters = %d" % n_clusters),
                     fontsize=14, fontweight='bold')

    plt.show()
    
    plt.plot(range(2, 10), distortions)
    plt.xlabel("Clusters")
    plt.ylabel("Distortions")
    plt.show()

Järgmiseks proovin klasterdamist, et vaadata, kas on võimalik andmeid klastritesse jaotada. Isiklikult arvan, et ei. Aga et kindel olla, siis proovin küünarnukki meetodit siluetidiagrammidel.

In [1760]:
draw_silhouette_plots(student_df_extra.values)
For n_clusters = 2 The average silhouette_score is : 0.5468948830687307
For n_clusters = 3 The average silhouette_score is : 0.5228355601330393
For n_clusters = 4 The average silhouette_score is : 0.5256810377093334
For n_clusters = 5 The average silhouette_score is : 0.4825687499187385
For n_clusters = 6 The average silhouette_score is : 0.4658916269870316
For n_clusters = 7 The average silhouette_score is : 0.47190446022596666
For n_clusters = 8 The average silhouette_score is : 0.4585603084493756
For n_clusters = 9 The average silhouette_score is : 0.4505743148035646

Ootuspäraselt ei tekkinud ilusaid eristatavaid klastreid kui anda palju andmeid sisse. Järgmiseks proovin vaadata, mis juhtub, kui osad väljad ära võtta.

In [1761]:
student_df_extra_only, extra_columns = load_dataset('students_extra_only.csv')
used_columns_extra = getColumns("students_extra_only.csv")

student_df_extra_only_pandas = pd.read_csv("students_extra_only.csv", 
                      header=2, 
                      names=used_columns_extra)

Siin on näha uued kasutusel olevad kolumnid ning nende jaotusdiagrammid, et saaks uurida, millised kolumnid kudidas omavahel seotud on.

In [1762]:
_ = scatter_matrix(student_df_extra_only_pandas ,figsize = (25, 25), alpha=0.8)
In [1763]:
draw_silhouette_plots(student_df_extra_only_pandas.values)
For n_clusters = 2 The average silhouette_score is : 0.7187492821512274
For n_clusters = 3 The average silhouette_score is : 0.7206387374319115
For n_clusters = 4 The average silhouette_score is : 0.4798973011186578
For n_clusters = 5 The average silhouette_score is : 0.48358624152741564
For n_clusters = 6 The average silhouette_score is : 0.48218496259634364
For n_clusters = 7 The average silhouette_score is : 0.3452718701274139
For n_clusters = 8 The average silhouette_score is : 0.35382178932402353
For n_clusters = 9 The average silhouette_score is : 0.33614828747599174

Vaadates nüüd klastrite kujunemist saab öelda, et erinevuseid leidub ning tudengeid saab klasterdada.

Klastrite arvu 3 puhul oli siluetti keskmine skoor: 0.7206387374319115, mis on päris hea.

Sellest saab järeldada, et tudengeid saab jagada kolme klastrisse.

Pideva väärtuse ennustamiseks loeb andmestiku uuesti sisse aga õigel kujul, et saaks neid lihtsamini kasutada

In [1764]:
import matplotlib.pyplot as plt
import csv
from sklearn.preprocessing import StandardScaler, MinMaxScaler, PolynomialFeatures
from sklearn.decomposition import PCA
from sklearn.metrics import accuracy_score, confusion_matrix, f1_score
from sklearn.feature_selection import SelectKBest
from sklearn.model_selection import cross_val_score, StratifiedKFold, train_test_split, learning_curve, GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
from sklearn.linear_model import Perceptron, LinearRegression, LogisticRegression
from sklearn.datasets.base import Bunch
from sklearn import utils
from sklearn.exceptions import ConvergenceWarning
from sklearn.ensemble import RandomForestRegressor

import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
warnings.filterwarnings("ignore", category=Warning)
warnings.filterwarnings("ignore", category=ConvergenceWarning)

student_df2, columns2 = load_dataset('students.csv')
print("Average grades after conversion:")
X_train, X_test, y_train, y_test = train_test_split(student_df2.data, student_df2.target, test_size=0.25, random_state=42)
print("Train:\n", y_train)
print("Test:\n", y_test)
Average grades after conversion:
Train:
 [ 80  70  80  70  90  90  90  30  10  90  70  90  20 100  80 100 100  60
 100 100  60 100  90  90  90  90  70  70  90  90  90  90  80  90  80  80
  90  90  60 100  80  90  90 100   0  20  80 100  90  90  90  70  90 100
  70  90  90  70  80  90  90  10  90   0  80  60  90  90  90  40  90  90
  90 100 100  90  90 100  90  90 100  90  90  50  60 100  70  90  90  90
  80  90  50 100 100 100  10  90  90  40 100  80  90]
Test:
 [ 60 100  90  90  90  60  90   0  80  90  80  80  90  90  90  90  90  80
  90  80 100  90 100  90 100  40  90  80  70  90  90  90 100  90  30]

Järgmiseks vaatab, kas andmeid on piisavalt, hinnates selle õppimiskõverat

In [1765]:
def validation_curve():
    train_sizes, train_scores, test_scores =\
                    learning_curve(estimator=pipe_lr,
                                   X=X_train,
                                   y=y_train,
                                   cv=10)

    train_mean = np.mean(train_scores, axis=1)
    train_std = np.std(train_scores, axis=1)
    test_mean = np.mean(test_scores, axis=1)
    test_std = np.std(test_scores, axis=1)

    %matplotlib inline

    plt.plot(train_sizes, train_mean,
             color='blue', marker='o',
             markersize=5, label='training accuracy')

    plt.fill_between(train_sizes,
                     train_mean + train_std,
                     train_mean - train_std,
                     alpha=0.15, color='blue')

    plt.plot(train_sizes, test_mean,
             color='green', linestyle='--',
             marker='s', markersize=5,
             label='validation accuracy')

    plt.fill_between(train_sizes,
                     test_mean + test_std,
                     test_mean - test_std,
                     alpha=0.15, color='green')

    plt.grid()
    plt.xlabel('Number of training samples')
    plt.ylabel('Accuracy')
    plt.legend(loc='lower right')
    plt.ylim([0, 1.0])
    plt.tight_layout()
    plt.show()
In [1766]:
def printScore():  # Cross validation
    scores = cross_val_score(estimator=pipe_lr,
                             X=X_train,
                             y=y_train,
                             cv=10)
    print('CV keskmine täpsus: %.3f' % abs(np.mean(scores)), "+/- %.3f" % np.std(scores))
    y_pred = [int(round(x / 10) * 10) for x in pipe_lr.predict(X_test)]
    print('F1 keskmine täpsus: %.3f' % f1_score(y_test, y_pred, average='micro'))
    print('Pipeline keskmine täpsus: %.3f' % pipe_lr.score(X_test, y_test))
In [1767]:
def print_confusion_matrix():
    print("\nEksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:")
    pipe_lr.fit(X_train, y_train)
    y_pred = [int(round(x / 10) * 10) for x in pipe_lr.predict(X_test)]
    confmat = confusion_matrix(y_true=y_test, y_pred=y_pred)
    cols = [str(i) for i in range(100 - (len(confmat) * 10) + 10, 110, 10)]
    df_cm = pd.DataFrame(confmat, index=cols, columns=cols)
    plt.figure(figsize = (10,7))
    sns.heatmap(df_cm, annot=True)
In [1768]:
def use_pipe_lr():
    validation_curve()
    print_confusion_matrix()
    printScore()
In [1769]:
pipe_lr = Pipeline([('tree', DecisionTreeRegressor())])

use_pipe_lr()
print("Vaadates jaotust on DecisionTreeRegressor paljutõotav")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 1.422 +/- 3.567
F1 keskmine täpsus: 0.486
Pipeline keskmine täpsus: 0.066
Vaadates jaotust on DecisionTreeRegressor paljutõotav
In [1770]:
pipe_lr = Pipeline([('sc1', SelectKBest(k=2)),
                    ('tree', DecisionTreeClassifier(max_depth=1))])

use_pipe_lr()
print("Päris hea tulemus. Hiljem proovin selle peal hüperparameetrite tuunimist")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.492 +/- 0.127
F1 keskmine täpsus: 0.514
Pipeline keskmine täpsus: 0.514
Päris hea tulemus. Hiljem proovin selle peal hüperparameetrite tuunimist
In [1771]:
pipe_lr = Pipeline(steps = [('lr', LinearRegression())])

use_pipe_lr()
print("Pipeline'ist on asju puudu")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 2.856 +/- 8.148
F1 keskmine täpsus: 0.229
Pipeline keskmine täpsus: 0.130
Pipeline'ist on asju puudu
In [1772]:
pipe_lr = Pipeline([('norm', StandardScaler()), 
                    ('lr', LinearRegression())])

use_pipe_lr()
print("Väärtused on kuidagi mööda ilma laiali")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 2.856 +/- 8.148
F1 keskmine täpsus: 0.229
Pipeline keskmine täpsus: 0.130
Väärtused on kuidagi mööda ilma laiali
In [1773]:
pipe_lr = Pipeline([('norm', MinMaxScaler()),
                    ('lr', LinearRegression())])

use_pipe_lr()
print("Ka MinMAxScaler'iga on väärtused igasse kanti")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 2.856 +/- 8.148
F1 keskmine täpsus: 0.229
Pipeline keskmine täpsus: 0.130
Ka MinMAxScaler'iga on väärtused igasse kanti
In [1774]:
pipe_lr = Pipeline(steps = [('pf', PolynomialFeatures()),
                            ('lr', LinearRegression())])

use_pipe_lr()
print("See on väga vale")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 16.126 +/- 21.720
F1 keskmine täpsus: 0.057
Pipeline keskmine täpsus: -32.070
See on väga vale

Lineaarne regressioon ei tundu sobiva variandina hetkel

In [1775]:
pipe_lr = Pipeline([('rfr', RandomForestRegressor())])

use_pipe_lr()
print("Siin ei tundu jaotus eriti hea")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 1.674 +/- 5.601
F1 keskmine täpsus: 0.371
Pipeline keskmine täpsus: 0.487
Siin ei tundu jaotus eriti hea
In [1776]:
pipe_lr = Pipeline([('sc1', SelectKBest(k=2)), 
                    ('rfr', RandomForestRegressor(n_estimators=50, criterion='mse'))])

use_pipe_lr()
print("RandomForestRegressor nii hea selle ülesane lahendamiseks pole")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 4.358 +/- 12.782
F1 keskmine täpsus: 0.429
Pipeline keskmine täpsus: 0.019
RandomForestRegressor nii hea selle ülesane lahendamiseks pole
In [1777]:
pipe_lr = Pipeline([('sc', MinMaxScaler()),
                    ('pca', PCA(n_components=2)),
                    ('per', Perceptron())])

use_pipe_lr()
print("Siin kaotatakse kuidagi väikesed väärtused ära")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.326 +/- 0.193
F1 keskmine täpsus: 0.514
Pipeline keskmine täpsus: 0.514
Siin kaotatakse kuidagi väikesed väärtused ära
In [1778]:
pipe_lr = Pipeline([('sc', StandardScaler()),
                    ('pca', PCA(n_components=2)),
                    ('per', Perceptron())])

use_pipe_lr()
print("Midagi hakkab looma. Hiljem katsetatakse hüperparameetritega")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.472 +/- 0.137
F1 keskmine täpsus: 0.371
Pipeline keskmine täpsus: 0.371
Midagi hakkab looma. Hiljem katsetatakse hüperparameetritega
In [1779]:
pipe_lr = Pipeline(steps = [('lr', LogisticRegression(random_state=0, solver="liblinear"))])

use_pipe_lr()
print("See on vägagi paljutõotav")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.559 +/- 0.176
F1 keskmine täpsus: 0.371
Pipeline keskmine täpsus: 0.371
See on vägagi paljutõotav
In [1780]:
pipe_lr = Pipeline(steps = [('pf', PolynomialFeatures()),
                            ('lr', LogisticRegression())])

use_pipe_lr()
print("PolynomialFeatures väga ei sobi")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.460 +/- 0.169
F1 keskmine täpsus: 0.400
Pipeline keskmine täpsus: 0.400
PolynomialFeatures väga ei sobi
In [1781]:
pipe_lr = Pipeline(steps = [('mms', MinMaxScaler()),
                            ('lr', LogisticRegression())])

use_pipe_lr()
print("MinMaxScaler on juba parem")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.549 +/- 0.147
F1 keskmine täpsus: 0.457
Pipeline keskmine täpsus: 0.457
MinMaxScaler on juba parem
In [1782]:
pipe_lr = Pipeline(steps = [('ss', StandardScaler()),
                            ('lr', LogisticRegression())])

use_pipe_lr()
print("StandardScaler sobib veidi paremini")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.544 +/- 0.143
F1 keskmine täpsus: 0.514
Pipeline keskmine täpsus: 0.514
StandardScaler sobib veidi paremini
In [1783]:
pipe_lr = Pipeline([('sc1', StandardScaler()),
                    ('pca', PCA()),
                    ('clf', LogisticRegression())])

use_pipe_lr()
print("PCA võib vahele visata, kuna worst case see ei tee midagi. Saadab selle konfiguratsiooni ka hüperparameetritega testimisele")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.544 +/- 0.143
F1 keskmine täpsus: 0.514
Pipeline keskmine täpsus: 0.514
PCA võib vahele visata, kuna worst case see ei tee midagi. Saadab selle konfiguratsiooni ka hüperparameetritega testimisele
In [1784]:
pipe_lr = Pipeline([('sc1', MinMaxScaler()),
                    ('pca', PCA(n_components=2)),
                    ('clf', LogisticRegression())])

use_pipe_lr()
print("StandardScaler tundus parem. Proovib tuunida hüperparameetritega")
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.538 +/- 0.141
F1 keskmine täpsus: 0.457
Pipeline keskmine täpsus: 0.457
StandardScaler tundus parem. Proovib tuunida hüperparameetritega

Mudeleid sai hinnatud kolmel moel:

* CV
* F1
* Pipeline.score

Vaadates eksimaatrikseid ning võrrelda täpsuseid siis kõige täpsem neist oli cross validation, mida ka edasipidi kasutan

Tulemused, mida proovib hüperparameetritega parendada:

* SelectKBest(k=2) ning  DecisionTreeClassifier(max_depth=1) andis tulemuseks 0.492 +/- 0.127
* StandardScaler(), PCA(n_components=2) ning Perceptron() andis tulemuseks 0.472 +/- 0.137
* StandardScaler(), PCA(n_components=2) ning LogisticRegression() andis tulemuseks 0.538 +/- 0.141

DecisionTreeClassifier tuunimine hüperparameetritega

In [1785]:
pipe_lr = Pipeline([('skb', SelectKBest()),
                    ('tree', DecisionTreeClassifier())])

param_grid = [{'skb__k': [1, 2, 3, 4, 5], 
               'tree__splitter': ["best", "random"],
               'tree__max_depth': [1, 2, 3, 4, 5, 10, 100],
               'tree__criterion': ["gini", "entropy"]
              }]

gs = GridSearchCV(estimator=pipe_lr, 
                  param_grid=param_grid, 
                  scoring='accuracy', 
                  cv=5,
                  n_jobs=-1)

gs = gs.fit(X_train, y_train)

print('Täpsus: ', gs.best_score_)
print(gs.best_params_) # {'skb__k': 4, 'tree__criterion': 'entropy', 'tree__max_depth': 2, 'tree__splitter': 'best'}

pipe_lr = Pipeline([('skb', SelectKBest(k=4)),
                    ('tree', DecisionTreeClassifier(criterion="entropy", max_depth=2, splitter="best"))])

use_pipe_lr()
Täpsus:  0.5145631067961165
{'skb__k': 4, 'tree__criterion': 'entropy', 'tree__max_depth': 2, 'tree__splitter': 'best'}
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.484 +/- 0.135
F1 keskmine täpsus: 0.486
Pipeline keskmine täpsus: 0.486
In [1786]:
pipe_lr = Pipeline([('sc', StandardScaler()),
                    ('pca', PCA(n_components=2)),
                    ('per', Perceptron())])

param_grid = [{'pca__n_components': [1, 2, 3, 4, 5], 
               'per__max_iter': [10, 100, 500, 1000],
               'per__penalty': ["l2", "l1", "elasticnet", "none"]
              }]

gs = GridSearchCV(estimator=pipe_lr, 
                  param_grid=param_grid, 
                  scoring='accuracy', 
                  cv=10,
                  n_jobs=-1)

gs = gs.fit(X_train, y_train)

print('Täpsus: ', gs.best_score_)
print(gs.best_params_) # {'pca__n_components': 2, 'per__max_iter': 100, 'per__penalty': 'l1'}

pipe_lr = Pipeline([('sc', StandardScaler()),
                    ('pca', PCA(n_components=2)),
                    ('per', Perceptron(max_iter=100, penalty="l1"))])

use_pipe_lr()
Täpsus:  0.4368932038834951
{'pca__n_components': 2, 'per__max_iter': 100, 'per__penalty': 'l1'}
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.454 +/- 0.098
F1 keskmine täpsus: 0.457
Pipeline keskmine täpsus: 0.457
In [1787]:
pipe_lr = Pipeline([('sc1', StandardScaler()),
                    ('pca', PCA()),
                    ('lgr', LogisticRegression())])

param_grid = [{'pca__n_components': [1, 2, 3, 4, 5], 
               'lgr__max_iter': [10, 100],
               'lgr__solver': ["newton-cg", "lbfgs", "sag", "saga"],
               'lgr__penalty': ["l2", "none"]
              }]

gs = GridSearchCV(estimator=pipe_lr, 
                  param_grid=param_grid, 
                  scoring='accuracy', 
                  cv=10,
                  n_jobs=-1)

gs = gs.fit(X_train, y_train)

print('Täpsus: ', gs.best_score_)
print(gs.best_params_) # {'lgr__max_iter': 100, 'lgr__penalty': 'none', 'lgr__solver': 'lbfgs', 'pca__n_components': 5}

pipe_lr = Pipeline([('sc1', StandardScaler()),
                    ('pca', PCA(n_components=5)),
                    ('lgr', LogisticRegression(max_iter=10, penalty='l2', solver='newton-cg'))])

use_pipe_lr()
Täpsus:  0.5145631067961165
{'lgr__max_iter': 10, 'lgr__penalty': 'l2', 'lgr__solver': 'newton-cg', 'pca__n_components': 5}
Eksimaatriks, kus telgedel on ennustatavad (y-telg) ja ennustatud(x-telg) väärtused:
CV keskmine täpsus: 0.550 +/- 0.137
F1 keskmine täpsus: 0.514
Pipeline keskmine täpsus: 0.514

Parim mudel keskmise hinde arvutamiseks järgmine:

* StandardScaler(), PCA(n_components=5) ning LogisticRegression(max_iter=10, penalty='l2', solver='newton-cg')

Kokkuvõte:

Tudengeid andis jagada kolme klastrisse nii, et siluetti skoor oli 0.72, mis oli parim skoor võimalike klastrite arvu poolest. Klastrid moodustusid tudengite õppeedukuse põhjal

Pideva muutuja ennustamisel valisin pidevaks muutujaks averageGrade'i. Parim mudel selle ennustamiseks oli pipeline, mis koosnes järgnevatest komponentidest:

  • StandardScaler()
  • PCA(n_components=5)
  • LogisticRegression(max_iter=10, penalty='l2', solver='newton-cg')

Ning mis koondus ilusti ning andis tulemuseks 0.55 +/- 0.137, mis ole just parim tulemus. Aga Kui järgmine aasta seda faili uuesti jooksutada, siis peaks see tulemus tõusma, kuna siis on juba rohkem andmeid tudengite testimiste kohta.

Kokkuvõte:

Tudengeid andis jagada kolme klastrisse nii, et siluetti skoor oli 0.72, mis oli parim skoor võimalike klastrite arvu poolest. Klastrid moodustusid tudengite õppeedukuse põhjal

Pideva muutuja ennustamisel valisin pidevaks muutujaks averageGrade'i. Parim mudel selle ennustamiseks oli pipeline, mis koosnes järgnevatest komponentidest:

  • StandardScaler()
  • PCA(n_components=5)
  • LogisticRegression(max_iter=10, penalty='l2', solver='newton-cg')

Ning mis koondus ilusti ning andis tulemuseks 0.55 +/- 0.137, mis ole just parim tulemus. Aga Kui järgmine aasta seda faili uuesti jooksutada, siis peaks see tulemus tõusma, kuna siis on juba rohkem andmeid tudengite testimiste kohta.

Kokkuvõte:

Tudengeid andis jagada kolme klastrisse nii, et siluetti skoor oli 0.72, mis oli parim skoor võimalike klastrite arvu poolest. Klastrid moodustusid tudengite õppeedukuse põhjal

Pideva muutuja ennustamisel valisin pidevaks muutujaks averageGrade'i. Parim mudel selle ennustamiseks oli pipeline, mis koosnes järgnevatest komponentidest:

  • StandardScaler()
  • PCA(n_components=5)
  • LogisticRegression(max_iter=10, penalty='l2', solver='newton-cg')

Ning mis koondus ilusti ning andis tulemuseks 0.55 +/- 0.137, mis ole just parim tulemus. Aga Kui järgmine aasta seda faili uuesti jooksutada, siis peaks see tulemus tõusma, kuna siis on juba rohkem andmeid tudengite testimiste kohta.